{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# VS C++"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**与 `Future`/`async` 的关系**\n",
    "\n",
    "`Pin` 在 `.await` 背后扮演着关键角色。编译器生成的状态机（`Future`）往往是自引用的：下一次 `poll` 要访问上次挂起时存储的局部变量。为了保证这些局部变量地址固定，`Future` 默认是 `!Unpin` 的，必须先通过 `Pin<Box<dyn Future>>` 或 `pin_utils::pin_mut!` 等方式固定，才能反复 `poll`。\n",
    "\n",
    "这也是为什么你在使用 `async fn` 时，常常能看到 `Pin<&mut Self>` 这样的签名：例如 `Future::poll(self: Pin<&mut Self>, cx: &mut Context<'_>)`。\n",
    "\n",
    "**何时应该用（或不用）`Pin`**\n",
    "\n",
    "1. **尽量避免自引用**：大多数场景可以通过 `Rc<RefCell<_>>`、`Arc<Mutex<_>>`、索引表等方式实现逻辑，避免直接持有自引用指针。\n",
    "2. **确实需要固定地址** 时再引入 `Pin`。典型例子：\n",
    "   - 自引用结构体（如你的例子、`async fn` 编译后的状态机）\n",
    "   - 驱动外部硬件或 C API 时，需要一个稳定地址注册回调\n",
    "3. **减少 `unsafe` 代码**：能用宏或辅助库尽量用，它们能帮你正确地投影字段。\n",
    "\n",
    "**小结**\n",
    "\n",
    "- 自引用类型的核心风险在于移动后指针失效。\n",
    "- `Pin` 提供了一种在语言层面声明「禁止再移动」的方式。\n",
    "- 要让 `Pin` 生效，需要让类型成为 `!Unpin`（通常通过 `PhantomPinned`）。\n",
    "- 使用 `Pin` 时，所有方法都应接受 `Pin<&Self>` 或 `Pin<&mut Self>`，避免绕过约束。\n",
    "- 配合 `pin-project` 等工具，可以在保持安全的同时减少 `unsafe`。\n",
    "\n",
    "掌握了这些原则，就能在 Rust 中安全地处理自引用类型和异步状态机，从而真正理解 `Pin` 的价值所在。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 设计目标与语言定位\n",
    "\n",
    "| 维度         | C++                                          | Rust                                                      |\n",
    "| ------------ | -------------------------------------------- | --------------------------------------------------------- |\n",
    "| 初始发布     | 1985 年                                      | 2015 年（1.0）                                            |\n",
    "| 核心目标     | 兼容 C、面向对象、泛型，高性能通用编程       | 零开销抽象、安全并发、现代系统级编程                      |\n",
    "| 与 C 兼容性  | 语言层面直接兼容                             | 通过 FFI 与 C 互操作，非直接兼容                          |\n",
    "| 标准制定     | ISO 标准委员会（CPPWG）                      | Rust Foundation + 社区驱动                                |\n",
    "| 语言发展节奏 | 大版本发布周期长（3 年左右）                 | 每 6 周一次稳定版发布                                     |\n",
    "| 主打场景     | 传统系统软件、游戏、嵌入式、金融、高性能计算 | 新一代系统软件、WebAssembly、云原生、嵌入式、安全并发软件 |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 内存管理与所有权\n",
    "\n",
    "| 主题                  | C++                                            | Rust                                          |\n",
    "| --------------------- | ---------------------------------------------- | --------------------------------------------- |\n",
    "| 所有权模型            | 手动管理（指针/引用），资源习惯用 RAII         | 编译期所有权/借用检查，`move`/`borrow` 语义   |\n",
    "| 自动资源释放          | 依赖析构函数、智能指针（`std::unique_ptr` 等） | `Drop` trait 自动释放，借用检查器确保安全释放 |\n",
    "| 垃圾回收              | 无内建 GC                                      | 无内建 GC                                     |\n",
    "| 空指针                | `nullptr`，需手动检查                          | 使用 `Option<T>` 明确表示可空性               |\n",
    "| 数据竞争（data race） | 编译器默认不阻止，需要程序员负责避免           | 编译器/类型系统在编译期阻止绝大多数数据竞争   |\n",
    "| 调试内存问题工具      | 常用 Valgrind、ASan、TSan 等                   | 内建借用检查 + Miri、ASan/TSan 集成           |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 类型系统与范式支持\n",
    "\n",
    "| 特性               | C++                                    | Rust                                                         |\n",
    "| ------------------ | -------------------------------------- | ------------------------------------------------------------ |\n",
    "| 类型推导           | `auto` / `decltype` / 模板推导         | `let` 绑定默认推导，类型后置（`x: i32`）                     |\n",
    "| 模板/泛型          | 模板（编译期多态），可特化             | 泛型 + trait bound，单态化（monomorphization）               |\n",
    "| trait/concept 支持 | C++20 concepts                         | trait（类似接口），trait object 运行时动态分发               |\n",
    "| 面向对象           | class/struct + 继承、多态              | struct/enum + impl + trait，对象安全 trait 作为 trait object |\n",
    "| 函数式支持         | `std::function`、lambda、`std::ranges` | 一等函数、闭包、迭代器链、`Option/Result`、模式匹配          |\n",
    "| 模式匹配           | `switch`（有限，需手动处理穿透）       | `match`、`if let`、`while let` 等结构化解构匹配              |\n",
    "| 空安全             | 依赖惯例和工具                         | 类型系统内建（`Option`）                                     |\n",
    "\n",
    "\n",
    "- **一等函数**：函数本身就是值，语言“开箱即用”地允许把函数像整数一样操作，闭包只是函数与环境的自然组合。\n",
    "- **C++ 函数对象**：通过让对象实现 `operator()` 来模拟“可调用”，加上模板与 `std::function` 等机制，使得 C++ 也能实践函数式风格；但从语言层面看，“函数”依然不是一等公民，而是“可调用对象”的一种特殊形态。\n",
    "\n",
    "因此，C++ 通过“可调用对象”的抽象（函数指针、函数对象、lambda、`std::function` 等）间接支持了一等函数的能力，但这一体验是由类型系统和库层组合出来的，而非语言核心直接赋予的统一语义"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 错误处理方式\n",
    "\n",
    "| 方面         | C++                                                 | Rust                                                         |\n",
    "| ------------ | --------------------------------------------------- | ------------------------------------------------------------ |\n",
    "| 主流方式     | 返回码、异常 (`throw`)、`std::expected`（C++23 起） | `Result<T, E>`，显式处理；`panic!` 仅用于不可恢复错误        |\n",
    "| 异常开销     | 有运行时开销，ABI 相关                              | 无运行时异常机制，`panic` 默认为非展开（`abort` 或 `unwind` 可选） |\n",
    "| 可恢复错误   | 需手动检查返回值或捕获异常                          | `?` 运算符链式传播 `Result`                                  |\n",
    "| 不可恢复错误 | `std::terminate` / `std::abort` / `assert`          | `panic!`，可在默认设置下终止线程或整个程序                   |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 并发与多线程\n",
    "\n",
    "| 对比点           | C++                                   | Rust                                                         |\n",
    "| ---------------- | ------------------------------------- | ------------------------------------------------------------ |\n",
    "| 内建线程库       | `std::thread`、`std::async`           | `std::thread`、`tokio` 等运行时，`Send`/`Sync` trait 保证安全 |\n",
    "| 数据共享         | 需手动管理锁与生命周期                | `Arc<T>`、`Mutex<T>`、`RwLock<T>` 等封装 + 类型系统检查      |\n",
    "| 数据竞争检测     | 编译器不阻止，依赖工具（TSan）        | 编译期借用检查 + `Send/Sync` trait 阻止大部分数据竞争        |\n",
    "| async/await 支持 | C++20 起提供 `co_await`，生态相对分散 | 稳定的 async/await，基于 `Future` trait，生态成熟（Tokio 等） |\n",
    "| 无锁编程         | 手动实现，依赖 `std::atomic`          | `std::sync::atomic` + `crossbeam` 等 crates                  |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 工具链与构建系统\n",
    "\n",
    "| 方面       | C++                                       | Rust                                         |\n",
    "| ---------- | ----------------------------------------- | -------------------------------------------- |\n",
    "| 构建系统   | CMake、Bazel、Meson、Make 等多样化        | 官方 `cargo`（编译、依赖、测试、发布一体化） |\n",
    "| 包管理     | 无官方统一方案（vcpkg、Conan、Hunter 等） | `crates.io` 官方仓库 + `cargo`               |\n",
    "| 编译器     | GCC、Clang、MSVC，ABI/特性差异较大        | `rustc` 主流，兼容性统一                     |\n",
    "| 格式化工具 | `clang-format`（非官方）、`astyle`        | 官方 `rustfmt`                               |\n",
    "| 静态分析   | Clang-Tidy、Coverity、SonarQube 等        | `clippy`、`cargo-audit`、`cargo-deny` 等     |\n",
    "| 文档生成   | Doxygen、Sphinx（需配置）                 | `cargo doc` 自动从注释生成 HTML 文档         |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 宏与元编程\n",
    "\n",
    "| 特性           | C++                                  | Rust                                       |\n",
    "| -------------- | ------------------------------------ | ------------------------------------------ |\n",
    "| 编译期编程     | 模板元编程、`constexpr`、`consteval` | `const fn`、`const generics`               |\n",
    "| 预处理器宏     | `#define`、条件编译                  | 无传统预处理器，使用 `cfg` 属性和宏系统    |\n",
    "| 过程宏         | 使用外部工具或复杂模板技巧           | 稳定过程宏（自定义派生、属性宏、函数式宏） |\n",
    "| 宏展开调试     | 较困难，常需外部工具                 | `cargo expand` 显示宏展开结果              |\n",
    "| 模板错误可读性 | 常常冗长、难以解析                   | 错误信息相对友好，编译器提供详细提示       |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 标准库与生态\n",
    "\n",
    "| 主题             | C++ 标准库                                                 | Rust 标准库/生态                                          |\n",
    "| ---------------- | ---------------------------------------------------------- | --------------------------------------------------------- |\n",
    "| 容器             | `std::vector`, `std::map`, `std::optional`, `std::variant` | `Vec`, `HashMap`, `Option`, `Result`, `VecDeque` 等       |\n",
    "| 字符串处理       | `std::string`, `std::wstring`                              | `String`, `&str`（UTF-8），`CString`                      |\n",
    "| 并发/同步        | `std::thread`, `std::mutex`, `std::future`                 | `std::thread`, `Mutex`, `RwLock`, `Arc`, async/await      |\n",
    "| 文件/IO          | `fstream`, `iostream`                                      | `std::fs`, `std::io`, `tokio::fs`                         |\n",
    "| 第三方生态       | 庞大但分散，包管理工具多                                   | crates.io 集中管理，依赖声明统一                          |\n",
    "| WebAssembly 支持 | Emscripten、wasm-bindgen（C++ 支持较复杂）                 | `wasm-pack`, `wasm-bindgen`, `yew`, `leptos` 等成熟工具链 |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 编译与性能\n",
    "\n",
    "| 项目         | C++                                                   | Rust                                                         |\n",
    "| ------------ | ----------------------------------------------------- | ------------------------------------------------------------ |\n",
    "| 编译速度     | 大型项目常见较慢编译；模块化（C++20 modules）尚在推广 | 编译速度中等，增量编译有优化；依赖较多时初次编译较慢         |\n",
    "| 生成代码质量 | 多编译器生态，可针对目标平台深度调优                  | LLVM 后端，生成代码质量通常与 Clang 相当                     |\n",
    "| 运行时开销   | 接近零开销抽象，取决于使用方式                        | 零开销抽象为设计目标，运行时开销可媲美 C/C++                 |\n",
    "| 二进制体积   | 取决于模板膨胀和链接器设置                            | `monomorphization` 可能导致模板类似的体积膨胀，但可通过 LTO 等优化 |\n",
    "| 跨平台       | 依赖编译器和标准库实现                                | 官方提供稳定的跨平台支持（Linux/Windows/macOS/嵌入式等）     |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 学习曲线与社区\n",
    "\n",
    "| 方面           | C++                                | Rust                                                       |\n",
    "| -------------- | ---------------------------------- | ---------------------------------------------------------- |\n",
    "| 学习曲线       | 历史包袱多、需要理解多种范式和细节 | 借用检查/所有权概念较新，入门门槛高，但规则统一            |\n",
    "| 资料与社区     | 资源丰富、但风格差异大             | 官方文档（The Rust Book）统一，社区友好                    |\n",
    "| 语言一致性     | 不同标准和编译器差异多             | 语言设计一致性高，稳定版向后兼容强                         |\n",
    "| 版本升级影响   | ABI/标准差异导致升级成本高         | 每 6 周小版本稳定发布，`rustup` 管理多版本方便             |\n",
    "| 生产环境成熟度 | 数十年成熟应用                     | 逐步在 Mozilla、Amazon、Microsoft、Google 等大型项目中应用 |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Rust: `enum` + `match` VS C++: `std::variant` + `std::visit`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| 特性     | Rust `enum`                                           | C++ `std::variant`                                           |\n",
    "| -------- | ----------------------------------------------------- | ------------------------------------------------------------ |\n",
    "| 定义     | 单一 `enum` 内部直接定义所有变体                      | 需要为每种变体准备 struct 或类型                             |\n",
    "| 匹配     | 内建 `match` 模式匹配语法，编译器检查是否覆盖所有分支 | 使用 `std::visit` + 访客对象；未覆盖所有分支会产生编译错误（若未提供对应 call operator） |\n",
    "| 数据绑定 | 语法简洁，变体可直接携带字段                          | 变体字段通常封装在 struct（或 tuple-like 类型）中            |\n",
    "| 扩展性   | 添加新变体需要修改 `match`                            | 添加新类型需更新 `variant` 类型列表和 visitor                |\n",
    "\n",
    "两者都实现了“同一枚举变量，根据具体分支执行不同逻辑”的核心能力，只是语法风格不同。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "rust"
    }
   },
   "outputs": [],
   "source": [
    "fn main() {\n",
    "    enum Message {\n",
    "        Quit,\n",
    "        Echo(String),\n",
    "        Move { x: i32, y: i32 },\n",
    "        ChangeColor(u8, u8, u8),\n",
    "    }\n",
    "\n",
    "    let messages = [\n",
    "        Message::Quit,\n",
    "        Message::Echo(\"hello Rust\".into()),\n",
    "        Message::Move { x: 3, y: -5 },\n",
    "        Message::ChangeColor(255, 215, 0),\n",
    "    ];\n",
    "\n",
    "    for message in messages {\n",
    "        handle_message(message);\n",
    "    }\n",
    "}\n",
    "\n",
    "fn handle_message(msg: Message) {\n",
    "    match msg {\n",
    "        Message::Quit => println!(\"Quit requested\"),\n",
    "        Message::Echo(text) => println!(\"Echo: {text}\"),\n",
    "        Message::Move { x, y } => println!(\"Move to ({x}, {y})\"),\n",
    "        Message::ChangeColor(r, g, b) => println!(\"Color set to RGB({r}, {g}, {b})\"),\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "cpp"
    }
   },
   "outputs": [],
   "source": [
    "#include <iostream>\n",
    "#include <string>\n",
    "#include <variant>\n",
    "#include <array>\n",
    "\n",
    "struct Quit {};\n",
    "struct Echo {\n",
    "    std::string text;\n",
    "};\n",
    "struct Move {\n",
    "    int x;\n",
    "    int y;\n",
    "};\n",
    "struct ChangeColor {\n",
    "    uint8_t r, g, b;\n",
    "};\n",
    "\n",
    "using Message = std::variant<Quit, Echo, Move, ChangeColor>;\n",
    "\n",
    "struct MessageHandler {\n",
    "    void operator()(const Quit&) const {\n",
    "        std::cout << \"Quit requested\\n\";\n",
    "    }\n",
    "    void operator()(const Echo& msg) const {\n",
    "        std::cout << \"Echo: \" << msg.text << '\\n';\n",
    "    }\n",
    "    void operator()(const Move& msg) const {\n",
    "        std::cout << \"Move to (\" << msg.x << \", \" << msg.y << \")\\n\";\n",
    "    }\n",
    "    void operator()(const ChangeColor& msg) const {\n",
    "        std::cout << \"Color set to RGB(\"\n",
    "                  << static_cast<int>(msg.r) << \", \"\n",
    "                  << static_cast<int>(msg.g) << \", \"\n",
    "                  << static_cast<int>(msg.b) << \")\\n\";\n",
    "    }\n",
    "};\n",
    "\n",
    "int main() {\n",
    "    std::array<Message, 4> messages{\n",
    "        Quit{},\n",
    "        Echo{\"hello C++\"},\n",
    "        Move{3, -5},\n",
    "        ChangeColor{255, 215, 0}\n",
    "    };\n",
    "\n",
    "    for (const auto& msg : messages) {\n",
    "        std::visit(MessageHandler{}, msg);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# trait\n",
    "\n",
    "在理解 Rust 的特征（trait）时，可以把它和其他常见语言中的类似概念类比：\n",
    "\n",
    "| 语言       | 类比对象                                                     | 相似点                                                       | 主要区别                                                     |\n",
    "| ---------- | ------------------------------------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ |\n",
    "| C++        | 1. **抽象类/纯虚函数**<br>2. **Concepts（C++20）**<br>3. **模板 + CRTP 模式** | 抽象类和纯虚函数描述一组需要实现的方法；Concepts/模板约束用来限制泛型参数的行为 | Rust trait 既能做静态分发（泛型约束）又能做动态分发（特征对象）。C++ 抽象类动态分发要依靠虚表，模板/Concepts 则是纯编译期；Rust 的对象安全规则和孤儿规则防止随意实现外部 trait |\n",
    "| Go         | `interface`                                                  | Go 接口和 Rust trait 一样定义了一组方法，实现者只需满足方法签名即可 | Go 的接口实现完全基于运行时检查，默认是动态分发；Rust 泛型+trait 默认为编译期单态化，只有使用 `dyn Trait` 时才动态分发 |\n",
    "| TypeScript | `interface` / `type` 中的结构化类型                          | 都是“鸭子类型”风格：只要实现了指定结构/方法集合，就视为符合接口 | TypeScript 接口仅在编译期（类型检查层面）起作用，运行时完全擦除；Rust trait 在编译期保证实现，还能生成具体代码或使用特征对象 |\n",
    "| Python     | 1. `abc` 模块中的抽象基类 (ABC)<br>2. `typing` 模块中的 Protocol（结构化接口） | ABC 和 Protocol 都能描述需要实现的方法集合                   | Python 接口检查多在运行期（尤其是 duck typing）；Protocol 需要 `from __future__ import annotations` 才能静态检查。Rust trait 在编译期强制检查，实现失配直接不通过编译 |\n",
    "\n",
    "总结：\n",
    "\n",
    "- Rust trait 最接近 “既能静态约束又能动态调度” 的接口机制。\n",
    "- 与 C++ 模板/Concepts 类似时，它走静态分发，单态化生成专用代码。\n",
    "- 与 Go/Python 接口类似时，可以借助 `dyn Trait` 做动态分发。\n",
    "- 与 TypeScript/Python 的结构化类型类似时，同样强调“只要实现了方法就能用”，但 Rust 在编译阶段就保证实现正确，避免运行期出错。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 特征对象（trait object）\n",
    "\n",
    "| 语言/范式                         | 类比对象                                     | 类比原因                                                     |\n",
    "| --------------------------------- | -------------------------------------------- | ------------------------------------------------------------ |\n",
    "| C++                               | 指向基类的指针/引用（带虚函数的类）          | 通过虚函数表（vtable）做运行期动态分发，与 Rust 的 `Box<dyn Trait>` / `&dyn Trait` 本质相同。 |\n",
    "| Java/C#                           | 接口类型引用（`Interface ref = new Impl()`） | 接口定义行为，多种实现类可统一操作；也是动态分发。           |\n",
    "| 动态语言（Python、JavaScript 等） | 鸭子类型（duck typing）                      | “看起来像鸭子就当成鸭子”，只要实现了所需方法就能调用。不过 Rust 在编译期检查 trait 实现。 |\n",
    "\n",
    "> 总结：特征对象就是“指向实现某个接口/抽象类的实例的引用”，让你在 Rust 中获得类似主流 OOP 中的多态与动态分发体验。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "C++17",
   "language": "C++17",
   "name": "xcpp17"
  },
  "language_info": {
   "name": "C++17"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
